Ich möchte damit beginnen, Ihnen zu sagen, dass ich sehr stolz auf dieses Tutorial bin. Als ich das erste Mal die Idee hatte einen AVI Player in OpenGL zu programmieren, muss ich mich bei Jonathan de Blok bedanken, da ich keine Idee hatte, wie ich einen AVI Player programmieren sollte. Ich fing damit an meine Sammlung an Programmierbüchern durchzugehen. Nicht eins hatte was über AVI-Dateien enthalten. Ich habe dann alles über das AVI Format gelesen, was die MSDN hergab. Viele nützliche Informationen in der MSDN, aber ich benötigte mehr Informationen.

Nachdem ich das Netz studenlang nach AVI-Beispielen durchsucht hatte, hatte ich nur zwei Seiten gebookmarked. Ich möchte nicht sagen, dass meine Suchmaschinen-Fähigkeiten herausragend sind, aber in 99,9% aller Fälle habe ich kein Problem, das zu finden, was ich suche. Ich war absolut geschockt, als ich realisierte, wie wenig AVI Beispiele es gab! Die meisten Beispiele, die ich gefunden habe, liesen sich nicht kompilieren... Eine Handvoll von denen war viel zu komplex (zumindest für mich) und der Rest tat zwar ihre Arbeit, war aber in VB, Delphi, etc. programmiert (nicht VC++).

Die erste Seite, die ich gespeichert hattee, war ein Artikel, geschrieben von Jonathan Nix, mit dem Titel "AVI Files". Sie können sich diesen unter http://www.gamedev.net/reference/programming/features/avifile/ anschauen. Großen Respekt für Jonathan dafür das er ein extrem brilliantes Dokument über das AVI Format geschrieben hat. Obwohl ich mich entschieden hatte, einige Sachen anders zu machen, machten seine Beispiels-Code-Schnippsel und klaren Kommentare den Lernprozess um ein vielfaches leichter! Die zweite Seite trägt den Namen "The AVI Overview" von John F. McGown, Ph.D.. Ich könnte stundenlang davon schwärmen, wie fantastisch John's Seite ist, aber es ist einfacher, wenn Sie sich das selbst anschauen! Die URL ist http://www.jmcgowan.com/avi.html. Seine Seite deckt so ziemlich alles ab, was es über das AVI-Format zu wissen gibt! Dank an John, dass er eine solch wertvolle Seite der Öffentlichkeit zur Verfügung stellt.

Das letzte was ich noch erwähnen möchte, ist, dass KEIN Code abgeschrieben wurde und auch kein Code kopiert wurde. Der Code wurde innerhalb von 3 Tagen mit Hilfe der oben genannten Seiten und Artikel geschrieben. Das gesagt, denke ich, ist es noch wichtig anzumerken, dass mein Code vielleicht NICHT der beste Weg ist, eine AVI Datei abzuspielen. Es mag vielleicht nicht mal der richtige Weg sein, um ein AVI abzuspielen, aber es funktioniert und ist einfach zu verwenden! Wenn Sie den Code oder mein Coding-Style nicht mögen oder Sie denken, dass ich der Programmier-Community damit weh tue, indem ich dieses Tutorial veröffentliche, dann haben Sie ein paar Möglichkeiten: 1) Durchsuchen Sie das Netz für alternative Ressourcen 2) Schreiben Sie ihren eigenen AVI Player ODER 3) schreiben Sie ein besseres Tutorial! Jeder der diese Seite besucht, sollte mittlerweile wissen, dass ich ein durchschnittlicher Programmierer mit durchschnittlichen Fähigkeiten bin (ich habe darauf auf unzähligen Pages auf dieser Seite hingewiesen)! Ich programmiere zum SPASS! Das Ziel dieser Seite ist es, das Leben der nicht-Elite Programmierer einfacher zu machen, mit OpenGL zu beginnen. Die Tutorials sind bloss Beispiele wie 'ich' es geschafft habe, einen bestimmten Effekt zu erreichen... Nicht mehr, nicht weniger!

Auf zum Code...

Das erste was Sie bemerken werden, ist, dass wir die Videor For Windows Header / Library inkludieren und linken. Großen Dank an Microsoft (Ich kann's nicht glauben, dass ich das gerade gesagt habe!). Diese Library macht es ein Leichtes AVI Dateien zu öffnen und abzuspielen! Bis jetzt... müssen Sie nur wissen, dass Sie den vfw.h Header inkludieren MÜSSEN und Sie müssen die vfw32.lib Library Datei linken, wenn Sie den Code kompilieren wollen :)

#include < windows.h>							// Header Datei für Windows
#include < gl\gl.h>							// Header Datei für die OpenGL32 Library
#include < gl\glu.h>							// Header Datei für die  GLu32 Library
#include < vfw.h>							// Header Datei für Video For Windows
#include "NeHeGL.h"							// Header Datei für NeHeGL

#pragma comment( lib, "opengl32.lib" )					// Suche nach OpenGL32.lib während des Linkens
#pragma comment( lib, "glu32.lib" )					// Suche nach GLu32.lib während des Linkens
#pragma comment( lib, "vfw32.lib" )					// Suche nach VFW32.lib während des Linkens

#ifndef CDS_FULLSCREEN							// CDS_FULLSCREEN ist von einigen
#define CDS_FULLSCREEN 4						// Compiler nicht definiert. Indem wir das hier definieren
#endif									// können wir Fehler vermeiden

GL_Window*	g_window;
Keys*		g_keys;

// Benutzerdefinierte Variablen
float		angle;							// Wird für Rotation verwendet
int		next;							// Wird für Animation verwendet
int		frame=0;						// Frame Counter
int		effect;							// aktueller Effekt
bool		sp;							// Leertaste gedrückt?
bool		env=TRUE;						// Environment Mapping (standardmäßig an)
bool		ep;							// 'E' gedrückt?
bool		bg=TRUE;						// Hintergrund (standardmäßig an)
bool		bp;							// 'B' gedrückt?

AVISTREAMINFO		psi;						// Zeiger auf eine Struktur, die die Stream Infos enthält
PAVISTREAM		pavi;						// Handle auf einen offenen Stream
PGETFRAME		pgf;						// Zeiger auf ein GetFrame Objekt
BITMAPINFOHEADER	bmih;						// Header Information für DrawDibDraw Decoding
long			lastframe;					// Letzter Frame des Streams
int			width;						// Video Breite
int			height;						// Video Höhe
char			*pdata;						// Zeiger auf die Texturdaten
int			mpf;						// wird die ungefähre Anzahl an Millisekunden pro Frame enthalten

GLUquadricObj *quadratic;						// Speicherplatz für unsere Quadratic Objekte

HDRAWDIB hdd;								// Handle für unser Dib
HBITMAP hBitmap;							// Handle auf ein Device abhängiges Bitmap
HDC hdc = CreateCompatibleDC(0);					// erzeugt einen kompatiblen Device Context
unsigned char* data = 0;						// Zeiger auf unser in der Größe angepasstes Image

void flipIt(void* buffer)						// tauscht die Rot und Blau Bytes (256x256)
{
	void* b = buffer;						// Zeiger auf den Buffer
	__asm								// es folgt Assembler Code
	{
		mov ecx, 256*256					// Initialisiere einen Zähler (Dimension des Speicherblocks)
		mov ebx, b						// ebx soll auf unsere Daten (b) zeigen
		label:							// Label das für die Schleife verwendet wird
			mov al,[ebx+0]					// Lade den Wert an ebx nachal
			mov ah,[ebx+2]					// Lade den Wert an ebx+2 nach ah
			mov [ebx+2],al					// Speichere Wert in al an ebx+2
			mov [ebx+0],ah					// Speichere Wert in ah an ebx

			add ebx,3					// Bewege 3 Bytes weiter in den Daten
			dec ecx						// dekrementiert unseren Schleifenzähler
			jnz label					// wenn noch nicht null dann springe zurück zum Label
	}
}

void OpenAVI(LPCSTR szFile)						// Öffnet eine AVI-Datei(szFile)
{
	TCHAR	title[100];						// wird den modifizierten Fenster-Titel enthalten

	AVIFileInit();							// Öffnet die AVIFile Library

	// Öffnet den AVI Stream
	if (AVIStreamOpenFromFile(&pavi, szFile, streamtypeVIDEO, 0, OF_READ, NULL) !=0)
	{
		// Ein Fehler ist beim Öffnen des Streams aufgetreten
		MessageBox (HWND_DESKTOP, "Failed To Open The AVI Stream", "Error", MB_OK | MB_ICONEXCLAMATION);
	}

	AVIStreamInfo(pavi, ψ, sizeof(psi));				// Liest Informationen über den Stream in psi ein
	width=psi.rcFrame.right-psi.rcFrame.left;			// Breite ist die rechte Seite des Frames minus links
	height=psi.rcFrame.bottom-psi.rcFrame.top;			// Höhe ist die untere Seite des Frames minus oben

	lastframe=AVIStreamLength(pavi);				// Der letzte Frame des Streams

	mpf=AVIStreamSampleToTime(pavi,lastframe)/lastframe;		// berechne die ungefähre Anzahl an Millisekunden pro Frame

	bmih.biSize		= sizeof (BITMAPINFOHEADER);		// Größe von BitmapInfoHeader
	bmih.biPlanes		= 1;					// Bitplanes
	bmih.biBitCount		= 24;					// das Bits Format welches wir haben wollen (24 Bit, 3 Bytes)
	bmih.biWidth		= 256;					// gewünschte Breite (256 Pixel)
	bmih.biHeight		= 256;					// gewünschte Höhe (256 Pixel)
	bmih.biCompression	= BI_RGB;				// angeforderter Modus = RGB

	hBitmap = CreateDIBSection (hdc, (BITMAPINFO*)(&bmih), DIB_RGB_COLORS, (void**)(&data), NULL, NULL);
	SelectObject (hdc, hBitmap);					// wähle hBitmap in unserem Device Context (hdc) aus

	pgf=AVIStreamGetFrameOpen(pavi, NULL);				// Erzeuge PGETFRAME unter der Benutzung des angeforderten Modus
	if (pgf==NULL)
	{
		// Ein Fehler ist beim Öffnen des Frames aufgetreten
		MessageBox (HWND_DESKTOP, "Failed To Open The AVI Frame", "Error", MB_OK | MB_ICONEXCLAMATION);
	}

	// Informationen für die Titelleiste (Breite / Höhe / Letzter Frame)
	wsprintf (title, "NeHe's AVI Player: Width: %d, Height: %d, Frames: %d", width, height, lastframe);
	SetWindowText(g_window->hWnd, title);				// Ändere die Titelleiste
}

void GrabAVIFrame(int frame)						// hole ein Frame aus demStream
{
	LPBITMAPINFOHEADER lpbi;					// enthält die Bitmap Header Informationen
	lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(pgf, frame);	// hole Daten aus dem AVI Stream
	pdata=(char *)lpbi+lpbi->biSize+lpbi->biClrUsed * sizeof(RGBQUAD);	// Zeiger auf die Daten, die von AVIStreamGetFrame zurückgegeben werden
										// (überspringe die Header Informationen, um an die Daten zu kommen)
	// konvertiere Daten in das geforderte Bitmap Format
	DrawDibDraw (hdd, hdc, 0, 0, 256, 256, lpbi, pdata, 0, 0, width, height, 0);

	flipIt(data);							// Tausche die Roten und Blauen Bytes (GL Kompatabilität)

	// aktualisiere die Textur
	glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, 256, 256, GL_RGB, GL_UNSIGNED_BYTE, data);
}

void CloseAVI(void)							// Schliesse die AVI-Datei korrekt
{
	DeleteObject(hBitmap);						// Lösche das Device abhängige Bitmap Objekt
	DrawDibClose(hdd);						// Schliesst den DrawDib Device Context
	AVIStreamGetFrameClose(pgf);					// De-alloziert die GetFrame Resourcen
	AVIStreamRelease(pavi);						// Gibt den Stream frei
	AVIFileExit();							// Gibt die File frei
}

BOOL Initialize (GL_Window* window, Keys* keys)				// Jeglicher GL Init Code & Benutzer Initialisierungen kommen hier hin
{
	g_window	= window;
	g_keys		= keys;

	// Fange mit der Benutzer Initialisierung an
	angle = 0.0f;							// Setze Anfangs Winkel auf 0
	hdd = DrawDibOpen();						// hole ein Device Context für unser Dib
	glClearColor (0.0f, 0.0f, 0.0f, 0.5f);				// schwarzer Hintergrund
	glClearDepth (1.0f);						// Depth Buffer Setup
	glDepthFunc (GL_LEQUAL);					// Die Art des Depth Testing (kleiner oder gleich)
	glEnable(GL_DEPTH_TEST);					// aktiviere Depth Testing
	glShadeModel (GL_SMOOTH);					// wähle Smooth Shading aus
	glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);		// Setze genaueste perspektiven Berechnung auf 

	quadratic=gluNewQuadric();					// erzeuge einen Zeiger auf das Quadric Objekt
	gluQuadricNormals(quadratic, GLU_SMOOTH);			// erzeuge 'smoothe' Normalenvektoren
	gluQuadricTexture(quadratic, GL_TRUE);				// erzeuge Texturkoordinaten

	glEnable(GL_TEXTURE_2D);					// aktiviere Textur Mapping
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);// Setze Textur Max Filter
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);// Setze Textur Min Filter

	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);		// Setze den Textur Generation Modus für S für's Sphere Mapping
	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);		// Setze Textur Generation Modus für T für's Sphere Mapping

	OpenAVI("data/face2.avi");					// Öffne die AVI Datei

	// erzeuge die Textur
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, data);

	return TRUE;							// gebe TRUE zurück (Initialisierung war erfolgreich)
}

void Deinitialize (void)						// Jegliche Benutzer DeInitialisation kommt hier hin
{
	CloseAVI();							// Schliesst die AVI-Datei
}

void Update (DWORD milliseconds)					// führe Bewegungs-Aktualisierung hier aus
{
	if (g_keys->keyDown [VK_ESCAPE] == TRUE)			// wurde ESC gedrückt?
	{
		TerminateApplication (g_window);			// beende das Programm
	}

	if (g_keys->keyDown [VK_F1] == TRUE)				// wurde F1 gedrückt?
	{
		ToggleFullscreen (g_window);				// wechsel Fullscreen Modus
	}

	if ((g_keys->keyDown [' ']) && !sp)				// wurde die Leertaste gedrückt und wird nicht noch immer gehalten?
	{
		sp=TRUE;						// Setze sp auf True
		effect++;						// Ändere Effekt (inkrementiere effect)
		if (effect>3)						// über unserem Limit?
			effect=0;					// Resette zurück auf 0
	}

	if (!g_keys->keyDown[' '])					// wurde Leertaste losgelassen?
		sp=FALSE;						// Setze sp auf False

	if ((g_keys->keyDown ['B']) && !bp)				// wurde 'B' gedrückt und wird nicht mehr gehalten? 
	{
		bp=TRUE;						// Setze bp auf True
		bg=!bg;							// wechsel Hintergrund aus/an
	}

	if (!g_keys->keyDown['B'])					// wurde 'B' losgelassen?
		bp=FALSE;						// Setze bp auf False

	if ((g_keys->keyDown ['E']) && !ep)				// wurde 'E' gedrückt und wird nicht mehr gehalten?
	{
		ep=TRUE;						// Setze ep auf True
		env=!env;						// wechsel Environment Mapping aus/an
	}

	if (!g_keys->keyDown['E'])					// wurde 'E' losgelassen?
		ep=FALSE;						// Setze ep auf False

	angle += (float)(milliseconds) / 60.0f;				// aktualisiere angle basierend auf dem Timer

	next+= milliseconds;						// inkrementiere next basierend auf dem Timer (Milliseconds)
	frame=next/mpf;							// berechne den aktuellen Frame

	if (frame>=lastframe)						// Haben wir den letzten Frame hinter uns?
	{
		frame=0;						// Resette den Frame zurück auf null (anfang des Videos)
		next=0;							// Resette den Animations Timer (next)
	}
}

void Draw (void)							// Zeichne unsere Szene
{
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		// lösche Screen und Depth Buffer

	GrabAVIFrame(frame);						// Hole ein Frame aus dem AVI
 

	if (bg)								// Ist der Hintergrund sichtbar?
	{
		glLoadIdentity();					// Resette die Modelview Matrix
		glBegin(GL_QUADS);					// fange an den Hintergrund zu zeichnen (ein Quad)
			// vordere Seite
			glTexCoord2f(1.0f, 1.0f); glVertex3f( 11.0f,  8.3f, -20.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f(-11.0f,  8.3f, -20.0f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f(-11.0f, -8.3f, -20.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f( 11.0f, -8.3f, -20.0f);
		glEnd();						// fertig mit dem Zeichnen des Hintergrunds
	}

	glLoadIdentity ();						// Resette die Modelview Matrix
	glTranslatef (0.0f, 0.0f, -10.0f);				// Translatiere 10 Einheiten in den Screen hinein

	if (env)							// Ist Environment Mapping an?
	{
		glEnable(GL_TEXTURE_GEN_S);				// aktiviere Texture Coord Generation für S (NEU)
		glEnable(GL_TEXTURE_GEN_T);				// aktiviere Texture Coord Generation für T (NEU)
	}

	glRotatef(angle*2.3f,1.0f,0.0f,0.0f);				// streue etwas Rotation ein, um die Dinge etwas umher zu bewegen
	glRotatef(angle*1.8f,0.0f,1.0f,0.0f);				// streue etwas Rotation ein, um die Dinge etwas umher zu bewegen
	glTranslatef(0.0f,0.0f,2.0f);					// Nach der Rotation translatiere zur neuen Position

	switch (effect)							// Welcher Effekt?
	{
	case 0:								// Effekt 0 - Würfel
		glRotatef (angle*1.3f, 1.0f, 0.0f, 0.0f);		// Rotiere auf der X-Achse um angle
		glRotatef (angle*1.1f, 0.0f, 1.0f, 0.0f);		// Rotiere auf der Y-Achse um angle
		glRotatef (angle*1.2f, 0.0f, 0.0f, 1.0f);		// Rotiere auf der Z-Achse um angle
		glBegin(GL_QUADS);					// fange an einen Würfel zu zeichnen
			// vordere Seite
			glNormal3f( 0.0f, 0.0f, 0.5f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
			// hintere Seite
			glNormal3f( 0.0f, 0.0f,-0.5f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
			// obere Seite
			glNormal3f( 0.0f, 0.5f, 0.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
			// untere Seite
			glNormal3f( 0.0f,-0.5f, 0.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
			// rechte Seite
			glNormal3f( 0.5f, 0.0f, 0.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
			// linke Seite
			glNormal3f(-0.5f, 0.0f, 0.0f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
		glEnd();						// fertig mit dem Zeichnen des Würfels
		break;							// Fertig mit Effekt 0

	case 1:								// Effekt 1 - Sphere
		glRotatef (angle*1.3f, 1.0f, 0.0f, 0.0f);		// Rotiere auf der X-Achse um angle
		glRotatef (angle*1.1f, 0.0f, 1.0f, 0.0f);		// Rotiere auf der Y-Achse um angle
		glRotatef (angle*1.2f, 0.0f, 0.0f, 1.0f);		// Rotiere auf der Z-Achse um angle
		gluSphere(quadratic,1.3f,20,20);			// zeichne eine Sphere
		break;							// fertig mit dem Zeichnen der Sphere

	case 2:								// Effekt 2 - Zylinder
		glRotatef (angle*1.3f, 1.0f, 0.0f, 0.0f);		// Rotiere auf der X-Achse  um angle
		glRotatef (angle*1.1f, 0.0f, 1.0f, 0.0f);		// Rotiere auf der Y-Achse um angle
		glRotatef (angle*1.2f, 0.0f, 0.0f, 1.0f);		// Rotiere auf der Z-chse um angle
		glTranslatef(0.0f,0.0f,-1.5f);				// zentriere den Zylinder
		gluCylinder(quadratic,1.0f,1.0f,3.0f,32,32);		// zeichne einen Zylinder
		break;							// fertig mit dem Zeichnen des Zylinders
	}

	if (env)							// Environment Mapping aktiviert?
	{
		glDisable(GL_TEXTURE_GEN_S);				// deaktiviere Texturkoordinaten Erzeugung für S (Neu)
		glDisable(GL_TEXTURE_GEN_T);				// deaktiviere Texturkoordinaten Erzeugung für T (Neu)
	}

	glFlush ();							// Flushe die GL Rendering Pipeline
}